// $ANTLR 2.7.5 (20050128): "fcl.g" -> "FCLLexer.java"$
package net.sourceforge.jFuzzyLogic.fcl;

import java.io.InputStream;
import java.io.Reader;
import java.util.Hashtable;

import antlr.ANTLRHashString;
import antlr.ByteBuffer;
import antlr.CharBuffer;
import antlr.CharStreamException;
import antlr.CharStreamIOException;
import antlr.InputBuffer;
import antlr.LexerSharedInputState;
import antlr.NoViableAltForCharException;
import antlr.RecognitionException;
import antlr.Token;
import antlr.TokenStream;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.TokenStreamRecognitionException;
import antlr.collections.impl.BitSet;

public class FCLLexer extends antlr.CharScanner implements FCLTokenTypes, TokenStream {

	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());

	private static final long[] mk_tokenSet_0() {
		long[] data = { -4398046520321L, -1L, 0L, 0L };
		return data;
	}

	private static final long[] mk_tokenSet_1() {
		long[] data = { -1025L, -1L, 0L, 0L };
		return data;
	}

	public FCLLexer(InputBuffer ib) {
		this(new LexerSharedInputState(ib));
	}

	public FCLLexer(InputStream in) {
		this(new ByteBuffer(in));
	}

	public FCLLexer(LexerSharedInputState state) {
		super(state);
		caseSensitiveLiterals = false;
		setCaseSensitive(false);
		literals = new Hashtable();
		literals.put(new ANTLRHashString("trape", this), new Integer(62));
		literals.put(new ANTLRHashString("act", this), new Integer(6));
		literals.put(new ANTLRHashString("log", this), new Integer(40));
		literals.put(new ANTLRHashString("sum", this), new Integer(58));
		literals.put(new ANTLRHashString("nsum", this), new Integer(47));
		literals.put(new ANTLRHashString("gbell", this), new Integer(32));
		literals.put(new ANTLRHashString("end_defuzzify", this), new Integer(24));
		literals.put(new ANTLRHashString("method", this), new Integer(42));
		literals.put(new ANTLRHashString("end_ruleblock", this), new Integer(27));
		literals.put(new ANTLRHashString("defuzzify", this), new Integer(21));
		literals.put(new ANTLRHashString("ruleblock", this), new Integer(54));
		literals.put(new ANTLRHashString("exp", this), new Integer(29));
		literals.put(new ANTLRHashString("min", this), new Integer(43));
		literals.put(new ANTLRHashString("probor", this), new Integer(49));
		literals.put(new ANTLRHashString("id", this), new Integer(35));
		literals.put(new ANTLRHashString("nc", this), new Integer(45));
		literals.put(new ANTLRHashString("abs", this), new Integer(4));
		literals.put(new ANTLRHashString("trian", this), new Integer(63));
		literals.put(new ANTLRHashString("and", this), new Integer(7));
		literals.put(new ANTLRHashString("sin", this), new Integer(56));
		literals.put(new ANTLRHashString("sigm", this), new Integer(55));
		literals.put(new ANTLRHashString("prod", this), new Integer(50));
		literals.put(new ANTLRHashString("gauss", this), new Integer(31));
		literals.put(new ANTLRHashString("bsum", this), new Integer(11));
		literals.put(new ANTLRHashString("accu", this), new Integer(5));
		literals.put(new ANTLRHashString("fuzzify", this), new Integer(34));
		literals.put(new ANTLRHashString("var_input", this), new Integer(65));
		literals.put(new ANTLRHashString("rm", this), new Integer(52));
		literals.put(new ANTLRHashString("bdif", this), new Integer(10));
		literals.put(new ANTLRHashString("end_var", this), new Integer(28));
		literals.put(new ANTLRHashString("ln", this), new Integer(39));
		literals.put(new ANTLRHashString("end_fuzzify", this), new Integer(26));
		literals.put(new ANTLRHashString("end_function_block", this), new Integer(25));
		literals.put(new ANTLRHashString("cogs", this), new Integer(14));
		literals.put(new ANTLRHashString("range", this), new Integer(51));
		literals.put(new ANTLRHashString("asum", this), new Integer(9));
		literals.put(new ANTLRHashString("tan", this), new Integer(59));
		literals.put(new ANTLRHashString("var_output", this), new Integer(66));
		literals.put(new ANTLRHashString("mm", this), new Integer(44));
		literals.put(new ANTLRHashString("function", this), new Integer(30));
		literals.put(new ANTLRHashString("cogf", this), new Integer(15));
		literals.put(new ANTLRHashString("lm", this), new Integer(38));
		literals.put(new ANTLRHashString("term", this), new Integer(60));
		literals.put(new ANTLRHashString("or", this), new Integer(48));
		literals.put(new ANTLRHashString("real", this), new Integer(64));
		literals.put(new ANTLRHashString("max", this), new Integer(41));
		literals.put(new ANTLRHashString("is", this), new Integer(37));
		literals.put(new ANTLRHashString("coa", this), new Integer(12));
		literals.put(new ANTLRHashString("cog", this), new Integer(13));
		literals.put(new ANTLRHashString("function_block", this), new Integer(33));
		literals.put(new ANTLRHashString("cos", this), new Integer(16));
		literals.put(new ANTLRHashString("if", this), new Integer(36));
		literals.put(new ANTLRHashString("singletons", this), new Integer(57));
		literals.put(new ANTLRHashString("default", this), new Integer(20));
		literals.put(new ANTLRHashString("rule", this), new Integer(53));
		literals.put(new ANTLRHashString("with", this), new Integer(67));
		literals.put(new ANTLRHashString("not", this), new Integer(46));
		literals.put(new ANTLRHashString("then", this), new Integer(61));
	}

	public FCLLexer(Reader in) {
		this(new CharBuffer(in));
	}

	public final void mASSIGN_OPERATOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = ASSIGN_OPERATOR;

		match(':');
		match('=');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COLON;

		match(':');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COMMA;

		match(',');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mCOMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COMMENT;

		match("(*");
		{
			_loop39: do {
				switch(LA(1)) {
					case '\r': {
						match('\r');
						match('\n');
						newline();
						break;
					}
					case '\n': {
						match('\n');
						newline();
						break;
					}
					case '\u0000':
					case '\u0001':
					case '\u0002':
					case '\u0003':
					case '\u0004':
					case '\u0005':
					case '\u0006':
					case '\u0007':
					case '\u0008':
					case '\t':
					case '\u000b':
					case '\u000c':
					case '\u000e':
					case '\u000f':
					case '\u0010':
					case '\u0011':
					case '\u0012':
					case '\u0013':
					case '\u0014':
					case '\u0015':
					case '\u0016':
					case '\u0017':
					case '\u0018':
					case '\u0019':
					case '\u001a':
					case '\u001b':
					case '\u001c':
					case '\u001d':
					case '\u001e':
					case '\u001f':
					case ' ':
					case '!':
					case '"':
					case '#':
					case '$':
					case '%':
					case '&':
					case '\'':
					case '(':
					case ')':
					case '+':
					case ',':
					case '-':
					case '.':
					case '/':
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
					case ':':
					case ';':
					case '<':
					case '=':
					case '>':
					case '?':
					case '@':
					case 'A':
					case 'B':
					case 'C':
					case 'D':
					case 'E':
					case 'F':
					case 'G':
					case 'H':
					case 'I':
					case 'J':
					case 'K':
					case 'L':
					case 'M':
					case 'N':
					case 'O':
					case 'P':
					case 'Q':
					case 'R':
					case 'S':
					case 'T':
					case 'U':
					case 'V':
					case 'W':
					case 'X':
					case 'Y':
					case 'Z':
					case '[':
					case '\\':
					case ']':
					case '^':
					case '_':
					case '`':
					case 'a':
					case 'b':
					case 'c':
					case 'd':
					case 'e':
					case 'f':
					case 'g':
					case 'h':
					case 'i':
					case 'j':
					case 'k':
					case 'l':
					case 'm':
					case 'n':
					case 'o':
					case 'p':
					case 'q':
					case 'r':
					case 's':
					case 't':
					case 'u':
					case 'v':
					case 'w':
					case 'x':
					case 'y':
					case 'z':
					case '{':
					case '|':
					case '}':
					case '~':
					case '\u007f': {
						{
							match(_tokenSet_0);
						}
						break;
					}
					default:
						if( ((LA(1) == '*') && ((LA(2) >= '\u0000' && LA(2) <= '\u007f')) && ((LA(3) >= '\u0000' && LA(3) <= '\u007f'))) && (LA(2) != ')') ) {
							match('*');
						} else {
							break _loop39;
						}
				}
			} while(true);
		}
		match("*)");
		_ttype = Token.SKIP;
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mCOMMENT_C(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COMMENT_C;

		match("/*");
		{
			_loop43: do {
				switch(LA(1)) {
					case '\r': {
						match('\r');
						match('\n');
						newline();
						break;
					}
					case '\n': {
						match('\n');
						newline();
						break;
					}
					case '\u0000':
					case '\u0001':
					case '\u0002':
					case '\u0003':
					case '\u0004':
					case '\u0005':
					case '\u0006':
					case '\u0007':
					case '\u0008':
					case '\t':
					case '\u000b':
					case '\u000c':
					case '\u000e':
					case '\u000f':
					case '\u0010':
					case '\u0011':
					case '\u0012':
					case '\u0013':
					case '\u0014':
					case '\u0015':
					case '\u0016':
					case '\u0017':
					case '\u0018':
					case '\u0019':
					case '\u001a':
					case '\u001b':
					case '\u001c':
					case '\u001d':
					case '\u001e':
					case '\u001f':
					case ' ':
					case '!':
					case '"':
					case '#':
					case '$':
					case '%':
					case '&':
					case '\'':
					case '(':
					case ')':
					case '+':
					case ',':
					case '-':
					case '.':
					case '/':
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
					case ':':
					case ';':
					case '<':
					case '=':
					case '>':
					case '?':
					case '@':
					case 'A':
					case 'B':
					case 'C':
					case 'D':
					case 'E':
					case 'F':
					case 'G':
					case 'H':
					case 'I':
					case 'J':
					case 'K':
					case 'L':
					case 'M':
					case 'N':
					case 'O':
					case 'P':
					case 'Q':
					case 'R':
					case 'S':
					case 'T':
					case 'U':
					case 'V':
					case 'W':
					case 'X':
					case 'Y':
					case 'Z':
					case '[':
					case '\\':
					case ']':
					case '^':
					case '_':
					case '`':
					case 'a':
					case 'b':
					case 'c':
					case 'd':
					case 'e':
					case 'f':
					case 'g':
					case 'h':
					case 'i':
					case 'j':
					case 'k':
					case 'l':
					case 'm':
					case 'n':
					case 'o':
					case 'p':
					case 'q':
					case 'r':
					case 's':
					case 't':
					case 'u':
					case 'v':
					case 'w':
					case 'x':
					case 'y':
					case 'z':
					case '{':
					case '|':
					case '}':
					case '~':
					case '\u007f': {
						{
							match(_tokenSet_0);
						}
						break;
					}
					default:
						if( ((LA(1) == '*') && ((LA(2) >= '\u0000' && LA(2) <= '\u007f')) && ((LA(3) >= '\u0000' && LA(3) <= '\u007f'))) && (LA(2) != '/') ) {
							match('*');
						} else {
							break _loop43;
						}
				}
			} while(true);
		}
		match("*/");
		_ttype = Token.SKIP;
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mCOMMENT_SL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = COMMENT_SL;

		match("//");
		{
			_loop46: do {
				if( (_tokenSet_1.member(LA(1))) ) {
					matchNot('\n');
				} else {
					break _loop46;
				}

			} while(true);
		}
		match('\n');
		_ttype = Token.SKIP;
		newline();
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = DOT;

		match('.');
		{
			if( (LA(1) == '.') ) {
				match('.');
				{
					switch(LA(1)) {
						case ' ': {
							match(' ');
							break;
						}
						case '\t': {
							match('\t');
							break;
						}
						case '\n': {
							match('\n');
							break;
						}
						case '\r': {
							match('\r');
							match('\n');
							break;
						}
						default: {
							throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
						}
					}
				}
				_ttype = DOTS;
			} else {}

		}
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mHAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = HAT;

		match('^');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = ID;

		{
			matchRange('a', 'z');
		}
		{
			_loop35: do {
				switch(LA(1)) {
					case 'a':
					case 'b':
					case 'c':
					case 'd':
					case 'e':
					case 'f':
					case 'g':
					case 'h':
					case 'i':
					case 'j':
					case 'k':
					case 'l':
					case 'm':
					case 'n':
					case 'o':
					case 'p':
					case 'q':
					case 'r':
					case 's':
					case 't':
					case 'u':
					case 'v':
					case 'w':
					case 'x':
					case 'y':
					case 'z': {
						matchRange('a', 'z');
						break;
					}
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9': {
						matchRange('0', '9');
						break;
					}
					case '_': {
						match('_');
						break;
					}
					default: {
						break _loop35;
					}
				}
			} while(true);
		}
		_ttype = testLiteralsTable(_ttype);
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mLEFT_CURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = LEFT_CURLY;

		match('{');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mLEFT_PARENTHESIS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = LEFT_PARENTHESIS;

		match('(');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = MINUS;

		match('-');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mNEWLINE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = NEWLINE;

		{
			switch(LA(1)) {
				case '\r': {
					match('\r');
					match('\n');
					break;
				}
				case '\n': {
					match('\n');
					break;
				}
				default: {
					throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
				}
			}
		}
		newline();
		_ttype = Token.SKIP;
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mPERCENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = PERCENT;

		match('%');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = PLUS;

		match('+');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mREAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = REAL;

		{
			int _cnt24 = 0;
			_loop24: do {
				if( ((LA(1) >= '0' && LA(1) <= '9')) ) {
					matchRange('0', '9');
				} else {
					if( _cnt24 >= 1 ) {
						break _loop24;
					}
					throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());

				}

				_cnt24++;
			} while(true);
		}
		{
			if( (LA(1) == '.') ) {
				match('.');
				{
					int _cnt27 = 0;
					_loop27: do {
						if( ((LA(1) >= '0' && LA(1) <= '9')) ) {
							matchRange('0', '9');
						} else {
							if( _cnt27 >= 1 ) {
								break _loop27;
							}
							throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
						}

						_cnt27++;
					} while(true);
				}
			} else {}

		}
		{
			if( (LA(1) == 'e') ) {
				match('e');
				{
					switch(LA(1)) {
						case '+': {
							mPLUS(false);
							break;
						}
						case '-': {
							mMINUS(false);
							break;
						}
						case '0':
						case '1':
						case '2':
						case '3':
						case '4':
						case '5':
						case '6':
						case '7':
						case '8':
						case '9': {
							break;
						}
						default: {
							throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
						}
					}
				}
				{
					int _cnt31 = 0;
					_loop31: do {
						if( ((LA(1) >= '0' && LA(1) <= '9')) ) {
							matchRange('0', '9');
						} else {
							if( _cnt31 >= 1 ) {
								break _loop31;
							}
							throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());

						}

						_cnt31++;
					} while(true);
				}
			} else {}

		}
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mRIGHT_CURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = RIGHT_CURLY;

		match('}');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mRIGHT_PARENTHESIS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = RIGHT_PARENTHESIS;

		match(')');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mSEMICOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = SEMICOLON;

		match(';');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mSLASH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = SLASH;

		match('/');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = STAR;

		match('*');
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
		int _ttype;
		Token _token = null;
		int _begin = text.length();
		_ttype = WS;

		{
			switch(LA(1)) {
				case ' ': {
					match(' ');
					break;
				}
				case '\t': {
					match('\t');
					break;
				}
				default: {
					throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
				}
			}
		}
		_ttype = Token.SKIP;
		if( _createToken && _token == null && _ttype != Token.SKIP ) {
			_token = makeToken(_ttype);
			_token.setText(new String(text.getBuffer(), _begin, text.length() - _begin));
		}
		_returnToken = _token;
	}

	public Token nextToken() throws TokenStreamException {
		Token theRetToken = null;
		if( theRetToken == null ) {

		}
		tryAgain: for( ;; ) {
			int _ttype = Token.INVALID_TYPE;
			resetText();
			try { // for char stream error handling
				try { // for lexical error handling
					switch(LA(1)) {
						case ',': {
							mCOMMA(true);
							theRetToken = _returnToken;
							break;
						}
						case '^': {
							mHAT(true);
							theRetToken = _returnToken;
							break;
						}
						case '{': {
							mLEFT_CURLY(true);
							theRetToken = _returnToken;
							break;
						}
						case '-': {
							mMINUS(true);
							theRetToken = _returnToken;
							break;
						}
						case '%': {
							mPERCENT(true);
							theRetToken = _returnToken;
							break;
						}
						case '+': {
							mPLUS(true);
							theRetToken = _returnToken;
							break;
						}
						case '}': {
							mRIGHT_CURLY(true);
							theRetToken = _returnToken;
							break;
						}
						case ')': {
							mRIGHT_PARENTHESIS(true);
							theRetToken = _returnToken;
							break;
						}
						case ';': {
							mSEMICOLON(true);
							theRetToken = _returnToken;
							break;
						}
						case '*': {
							mSTAR(true);
							theRetToken = _returnToken;
							break;
						}
						case '.': {
							mDOT(true);
							theRetToken = _returnToken;
							break;
						}
						case '\t':
						case ' ': {
							mWS(true);
							theRetToken = _returnToken;
							break;
						}
						case '\n':
						case '\r': {
							mNEWLINE(true);
							theRetToken = _returnToken;
							break;
						}
						case '0':
						case '1':
						case '2':
						case '3':
						case '4':
						case '5':
						case '6':
						case '7':
						case '8':
						case '9': {
							mREAL(true);
							theRetToken = _returnToken;
							break;
						}
						case 'a':
						case 'b':
						case 'c':
						case 'd':
						case 'e':
						case 'f':
						case 'g':
						case 'h':
						case 'i':
						case 'j':
						case 'k':
						case 'l':
						case 'm':
						case 'n':
						case 'o':
						case 'p':
						case 'q':
						case 'r':
						case 's':
						case 't':
						case 'u':
						case 'v':
						case 'w':
						case 'x':
						case 'y':
						case 'z': {
							mID(true);
							theRetToken = _returnToken;
							break;
						}
						default:
							if( (LA(1) == ':') && (LA(2) == '=') ) {
								mASSIGN_OPERATOR(true);
								theRetToken = _returnToken;
							} else if( (LA(1) == '(') && (LA(2) == '*') ) {
								mCOMMENT(true);
								theRetToken = _returnToken;
							} else if( (LA(1) == '/') && (LA(2) == '*') ) {
								mCOMMENT_C(true);
								theRetToken = _returnToken;
							} else if( (LA(1) == '/') && (LA(2) == '/') ) {
								mCOMMENT_SL(true);
								theRetToken = _returnToken;
							} else if( (LA(1) == ':') && (true) ) {
								mCOLON(true);
								theRetToken = _returnToken;
							} else if( (LA(1) == '(') && (true) ) {
								mLEFT_PARENTHESIS(true);
								theRetToken = _returnToken;
							} else if( (LA(1) == '/') && (true) ) {
								mSLASH(true);
								theRetToken = _returnToken;
							} else {
								if( LA(1) == EOF_CHAR ) {
									uponEOF();
									_returnToken = makeToken(Token.EOF_TYPE);
								} else {
									throw new NoViableAltForCharException((char) LA(1), getFilename(), getLine(), getColumn());
								}
							}
					}
					if( _returnToken == null ) continue tryAgain; // found SKIP token
					_ttype = _returnToken.getType();
					_returnToken.setType(_ttype);
					return _returnToken;
				} catch(RecognitionException e) {
					throw new TokenStreamRecognitionException(e);
				}
			} catch(CharStreamException cse) {
				if( cse instanceof CharStreamIOException ) { throw new TokenStreamIOException(((CharStreamIOException) cse).io); }
				throw new TokenStreamException(cse.getMessage());

			}
		}
	}

}
